//全排列

// var backtrack = function(list,tmp,nums){
//     //终止条件
//     if(tmp.length === nums.length){
//         return list.push([...tmp])
//     }
//     for(let i=0;i<nums.legnht;i++){
//         if(tmp.includes(nums[i])){
//             continue
//         }
//         tmp.push(nums[i])
//         backtrack(list,tmp,nums)
//         tmp.pop()
//     }
// }
// var permute = function(nums){
//     if(!nums) return nums
//     let list = [] //用于存放结果
//     let tmp = [] //临时存放的容器
//     backtrack(list,tmp,nums)
//     return list
// }

//跳跃游戏
//贪心: 不用考虑每一步跳跃到那个位置，而是尽可能的跳跃到最远的位置，看最多能覆盖的位置，不断更新能覆盖的距离
// var junp = function(nums){
//     let cover = 0
//     for(let i=0;i<=cover;i++){
//         cover = Math.max(cover,i+nums[i])
//         if(cover>=nums.length-1){
//             return true
//         }
//     }
//     return false
// }
// let arr = [2,3,1,1,4]
// junp(arr)

//找零钱   动态规划
// var find = function(coins,amount){
//     if(!amount){
//         return 0;
//     }
//     let dp = Array(amount+1).fill(Infinity)
//     dp[0] = 0
//     for(let i=0;i<coins.length;i++){
//         for(let j=coins[i];j<=amount;j++){
//             // 比如说当前j为11，选择的硬币大小为5,
//             // dp[j-coins[i]]+1  表示当前目标数减去当前硬币大小 得到的就是dp[]就是之前的另一个目标所需的硬币数而加上这个1就相当于等于dp[j]
//             dp[j] = Math.min(dp[j-coins[i]] + 1,dp[j])//为什么+1？是因为选择到了当前硬币数，然后在加上一枚当前的硬币
//         }
//     }
//     return dp[amount] === Infinity ? -1 : dp[amount]
// }
// let coins = [1,2,5]
// let amount = 11
// find(coins,amount)

//最长递增子序列
// var maxChildren = function(nums){
//     let n = nums.length
//     if(n === 0 ) return 0
//     let dp = Array(n).fill(1)
//     for(let i=0;i<n;i++){
//         for(let j=0;j<i;j++){
//             if(nums[i]>nums[j]){
//                 dp[i] = Math.max(dp[i],dp[j]+1)
//             }
//         }
//     }
//     return Math.max(...dp)
// }

// var maxChildren1 = function(nums){
//     let n = nums.length
//     if(n==0){
//         return 0
//     }
//     let arr = [nums[0]]
//     for(let i=0;i<n;i++){
//         if(nums[i]>arr[arr.length-1]){//当前值比数组最后一个大，直接push进去
//             arr.push(nums[i])
//         }else{//如果比他小就找到对应的位置替换，二分查找
//             let left = 0
//             let right = arr.length - 1
//             while(left<right){
//                 let mid = (left+right) >> 1
//                 if(arr[mid]<nums[i]){//如果中间值比当前值小
//                     left = mid + 1
//                 }else {
//                     right  = mid
//                 }
//             }
//             arr[left] = nums[i]
//         }
//     }
//     return arr.length
// }

// let nums = [0,1,1,3,2,3]
// maxChildren1(nums)

// var removeDuplicates = function(nums) {
//     let n = nums.length
//     let i = 0 //标记长度
//     for(let j=1;j<n;j++){
//         if(nums[i] != nums[j]){//如果相等 删除当前元素
//             i++
//             nums[i]=nums[j]
//         }
//     }
//     return i
// };

// nums = [1,1,2]

// removeDuplicates(nums)

// var po = function(nums,val){
//     let k =0
//     for(let i=0;i<nums.length;i++){
//         if(nums[i] !== val ){
//             nums[k++] = nums[i]
//         }
//     }
//     return k
// }

// po([3,2,2,3],3)

// var twoSum = function(numbers, target) {
//     //双指针
//     let left = 0
//     let right = numbers.length-1
//     while(left<right){
//         if(numbers[right]>target){//先走右边，让右边走到小于目标为止
//             right--
//             continue
//         }
//         if(target - numbers[right] > numbers[left]){//减出来的值大于，左边的值，说明左边太小了
//             left++
//         }else if(target - numbers[left] < numbers[right] ){
//             right--
//         }else{
//             return [left,right]
//         }
//     }
//     return fasle

// }
// let numbers = [2,7,11,15]
// let target = 9
// twoSum(numbers, target)

// var minSubArrayLen = function(target, nums) {
//     let fast = slow = 0
//     let len = nums.length
//     let ret = len + 1
//     let sum = 0
//     while(fast<len){
//         sum += nums[fast++]
//         while(sum >= target){
//             let sublen = fast - slow
//             ret = ret<sublen ? ret : sublen
//             sum -=nums[slow++]
//         }
//     }
//     return  ret < len+1 ? ret : 0

// }
// minSubArrayLen(15, [1,2,3,4,5])
// var doubleTree = function(root){
//     var tree = function(root1,root2){
//         if(root1.val!==root2.val){
//             return false
//         }

//         tree(root1.left,root2.right)
//         tree(root1.right,root2.left)
//     }
//     tree(root.left,root.right)
//     return true
// }

// instanceof原理
// const intanceofs = function(left,right){
//     //获取左边的原型  左边传的对象
//     let leftVal = left.__proto__
//     let rightVal = left.prototype
//     while(leftVal){
//         if(!leftVal) return false
//         if(leftVal === rightVal){
//             return true
//         }
//         //继续往原型链上找
//         leftVal = leftVal.__proto__
//     }
// }

//防抖封装

// let ipt = document.querySelector('#app')
// let = null
// ipt.oninput = debounce(function(){
//     console.log(this.value);
// },delay)

// function debounce(callback,delay){
//     let timer = null
//     return function(){
//         if(timer !== null){
//             clearTimeout(timer)
//         }

//         timer = setTimeout(()=>{
//             callback().call(this)//修正this的指向
//         },delay)
//     }
// }

//节流封装:控制执行次数  用一个标记初始为true  放在定时器里面执行完就变为false
// let flag = true
// function throttle(callback,delay){
//     return function(){
//         if(flag){
//             setTimeout(()=>{
//                 callback().call(this)//修正this的指向
//                 flag = true
//             },delay)
//         }
//         flag = false;
//     }
// }

var removeDuplicates = function (nums) {
  let left = 0
  let right = 0
  for (let i = 0; i <= nums.length; i++) {
    if (nums[left] == nums[right]) {
      right++
    } else {
      ;[nums[left + 1], nums[right]] = [nums[right], nums[left + 1]]
      right++
      left++
    }
  }
  return nums
}

nums = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4]
removeDuplicates(nums)
